Cette formation a pour but de rendre accessible Ć tous la programmation en R. Pour cela, nous introduirons la notion de programmation dans un contexte gĆ©nĆ©ral, puis nous nous pencherons sur le langage R en partant dāune vue globale pour entrer petit Ć petit dans les manipulations techniques.
Comme nous lāinforme WikipĆ©dia, la programmation - aussi appelĆ©e codage ou dĆ©veloppement, dĆ©signe lāensemble des activitĆ©s qui permettent lāĆ©criture de programmes informatiques. Cette Ć©criture de programmes se fait dans un langage de programmation, les 10 principaux langages sont les suivants : HTML/CSS, JavaScript, PHP, Ruby, Java, Swift, C#, C ou C++, Python, Julia et Scala. R est aussi un langage de programmation qui est, lui, davantage axĆ© sur lāanalyse statistique.
La troisiĆØme rĆ©volution industrielle, connue sous le nom de ārĆ©volution informatiqueā sāaccompagne dāune crĆ©ation de 2.5 trillions dāoctets de donnĆ©es chaque jour. Cāest dans ce contexte dāabondance des donnĆ©es quāest nĆ©e la science des donnĆ©es, visant Ć obtenir des informations et des connaissances Ć partir des donnĆ©es qui gĆ©nĆØrent de la valeur. Le schĆ©ma ci-dessous peut aider Ć comprendre comment exploiter la valeur des donnĆ©es :
Comme dit précédemment R est un langage de programmation en libre accès créé en 1993, destiné aux statistiques et à la science des données.
Gratuit, facile dāaccĆØs, puissant, reproductible, design, le langage R est Ć la fois pertinent pour analyser les donnĆ©es, les visualiser et gĆ©nĆ©rer des rapports qui permettent - comme celui-ci, de mĆ©langer du code, du texte et des graphiques.
Pour coder en R on utilise gĆ©nĆ©ralement lāinterface R studio qui permet dāinteragir avec le langage R de maniĆØre aisĆ©e. Quoi quāil en soit, lāimage partagĆ©e par Sylvain montre que la programmation est un apprentissage infini :
Pour installer lāinterface RStudio il faut dans un premier temps installer R et dans un second temps tĆ©lĆ©charger lāapplication RStudio. Les liens de tĆ©lĆ©chargements sont disponibles sur le site rstudio.com.
Une fois lāinstallation terminĆ©e, il est important de configurer RStudio pour faciliter le travail sur lāinterface et les partages de documents. Les paramĆØtres gĆ©nĆ©raux se trouvent dans le menu : Tools > Global Options
Vous pouvez configurer le āGeneralā et le āCodeā de la maniĆØre suivante :
Il est aussi important de configurer la sauvegarde des scripts ; il faut spĆ©cifier un codage āUTF-8ā pour que les caractĆØres spĆ©ciaux de chaque script enregistrĆ© soient traitĆ©s correctement, et ainsi faciliter le partage de codes. Cette option est disponible dans la fenĆŖtre des Global Options > Code > Saving > Default text encoding > Change⦠> UTF-8. Enfin, dans cette mĆŖme fenĆŖtre des options gĆ©nĆ©rales de RStudio - dans lāoption āAppearanceā, vous pouvez personnaliser lāapparence de votre interface en modifiant la police, la taille du texte, le thĆØme etc.
Ne pas oublier dāappliquer ces changements (āApplyā) avant de fermer la fenĆŖtre des options (āOkā).
Une fenĆŖtre R Ć son ouverture est dĆ©composĆ©e en 3 parties, 4 en diminuant la taille de la partie infĆ©rieure en cliquant sur le bouton (ou via le menu : View > Panes > Show all panes). La programmation Ć proprement parler se fait dans la partie supĆ©rieure gauche, cāest lĆ où on Ć©crit les scripts que lāon pourra ensuite sauvegarder.
NB : il est aussi possible de coder directement dans la console (partie inférieure gauche), la commande sera exécutée mais ne sera pas sauvegardée ; ça peut donc être intéressant pour exécuter une commande de manière instantanée (un calcul par exemple).
La partie infƩrieure droite est dƩcomposƩe en 5 onglets :
Un avantage incontournable de R est la communautĆ© qui existe autour pour trouver des ressources, de lāaide, de lāinspiration etc. On trouve notamment R-bloggers avec des nouveautĆ©s et des tutoriels Ć©crits par des utilisateurs du langage, RStudio Community pour trouver/donner de lāaide (comme un #TeamOpenData de RStudio), Stack Overflow où lāon trouve la majoritĆ© des rĆ©ponses aux questions de programmation - la plateforme nāest cependant pas propre Ć R.
Il est aussi possible de relier RStudio à Git, ce qui permet de déposer du code, des bases de données et des objets créés (graphiques, cartes, documents html..) sur github. Les fichiers sont ainsi centralisés et sauvegardés sur un repository qui permet de collaborer facilement sur un projet.
coder = programmer
ligne de commande = ligne de code
runer = exĆ©cuter une commande (bouton āRunā)
package = ensemble de fonctions
library = endroit où sont gardés les packages
working directory = rƩpertoire de travail
Les principaux documents que lāon peut crĆ©er Ć partir de lāinterface RStudio sont les suivants :
Pour crĆ©er un nouveau document il faut aller dans le menu : File > New File > choisir celui que vous voulez crĆ©er, ou sur le juste en dessous du āFileā dans la barre de menu.
Ces documents peuvent ĆŖtre crƩƩs/ouverts seuls ou dans un projet : . Un Rproject est utile dĆØs lors que lāon travaille sur une analyse avec de nombreux fichiers (donnĆ©es, scripts, imagesā¦) et en collaboration avec dāautres personnes. Il est effectivement possible dāorganiser son espace de travail Ć partir de lāobjet ā.Rprojā :
Organisation du travail dans le dossier de la machine
Ouverture du projet sous RStudio, accès facilité aux fichiers
data <- read_csv("C:/Users/name/desktop/mon_projet/data/base.csv")
La limite de cette mĆ©thode apparaĆ®t quand on veut partager le code Ć quelquāun dāautre qui nāaura pas le mĆŖme chemin dāaccĆØs (ne serait-ce que pour le nom dāutilisateur). En travaillant dans un projet R, les chemins dāaccĆØs aux documents seront relatifs puisquāils dĆ©butent Ć lāendroit où lāon travaille (working directory), cāest-Ć -dire Ć lāemplacement du .Rproj. La commande pour importer les donnĆ©es avec le chemin relatif serait la suivante :
data <- read_csv("./data/base.csv")
Le point ā.ā correspond au rĆ©pertoire de travail cāest-Ć -dire Ć lāemplacement du RProject ici. Le dossier avec le projet R peut ĆŖtre dĆ©placĆ© et partagĆ©, lāimport continuera de fonctionner grĆ¢ce au chemin relatif.
Pour crĆ©er un nouveau projet il faut aller dans le menu : File > New Project > New Directory > New Project > entrer un nom de projet, Ć©ventuellement changer lāespace de travail > Create Project, ou Ć partir du juste en dessous du āEditā dans la barre de menu.
Bonne pratique
Un bon rĆ©flexe Ć prendre dĆØs le dĆ©but de votre carriĆØre de programmeur est de ne laisser aucun espace blanc dans les noms des fichiers/dossiers, de maniĆØre Ć ce quāils puissent ĆŖtre lus Ć la fois par des personnes mais aussi par des machines. Les bons sĆ©parateurs des mots sont alors -ou _. Il est aussi recommandĆ© de ne pas mettre dāaccent, pour prĆ©venir dāĆ©ventuels problĆØmes dāencodage.
Exemple de mauvais nom : Extraction des donnƩes de data.gouv.R
Exemple de bon nom : Extraction_donnees_data-gouv.R
Maintenant que la notion de programmation est plus claire et que vous connaissez les rouages du langage R, nous allons entrer dans le vif du sujet en apprenant Ć manier les donnĆ©es ; que ce soit la mise en forme, lāanalyse ou la visualisation. Cette partie reprendra Ć©tape par Ć©tape le schĆ©ma dāexploitation des donnĆ©es que nous avons vu en premiĆØre partie :
Avant de nous pencher sur lāimport de donnĆ©es, voyons les deux maniĆØres de coder en R : le R-base et le tidyverse. La programmation dans le langage R a Ć©tĆ© rĆ©volutionnĆ©e ces derniĆØres annĆ©es par le statisticien Hadley Wickham et son Ć©quipe, qui ont dĆ©veloppĆ© le tidyverse. Contraction de tidy et universe, le tidyverse est une collection de packages R qui ont tous la mĆŖme structure, simplifiant ainsi leur utilisation pour la data science.
Le tidyverse fonctionne grĆ¢ce au pipe (%>%) contenu dans le package magrittr, qui permet dāappliquer un certain nombre de fonctions Ć une base de donnĆ©es. Le code est alors plus lisible grĆ¢ce Ć une structuration des sĆ©quences dāopĆ©rations de gauche Ć droite (et non de lāextĆ©rieur Ć lāintĆ©rieur comme en R-base), qui permet dāajouter des Ć©tapes nāimporte où dans les sĆ©quences dāopĆ©rations.
Un exemple de code en R-base et en tidyverse :
h(g(f(x)))x %>% f %>% g %>% hNous apprendrons Ć coder seulement en tidyverse dont lāapproche est beaucoup plus simple pour dĆ©buter la programmation.
Pour exécuter du code il faut placer son curseur sur la ligne de commande, puis cliquer sur le bouton en haut de la fenêtre, ou appuyer sur les touches Ctrl-Enter. Pour exécuter plusieurs lignes de code simultanément il suffit de les sélectionner avant de les runer. vous pouvez notamment vous entraîner en runant de simples opérations arithmétiques :
13+4
#> [1] 17
5*2
#> [1] 10
13+4-5*2
#> [1] 7
Il est possible dāassigner une valeur Ć un objet (dataframe, liste, vecteur, fonctionā¦) avec <- ou =, de maniĆØre Ć les sauvegarder dans lāenvironnement de travail (partie en haut Ć droite de la fenĆŖtre RStudio). Vous pouvez par exemple runer les commandes suivantes :
# OpƩrations
x <- 13+4
y <- 5*2
# Calcul du rƩsultat
resultat = x-y
resultat
#> [1] 7
De cette maniĆØre, le code sous R se lit de droite Ć gauche ;
Bonne pratique
Tout texte peut ĆŖtre intĆ©grĆ© dans un script R aprĆØs un ā#ā ; il ne sera pas considĆ©rĆ© comme du code mais comme un commentaire donc ne sera pas exĆ©cutĆ©. Un bon rĆ©flexe est de mettre le plus dāexplications du code grĆ¢ce aux ā#ā, pour quāil soit lisible et comprĆ©hensible par toute personne qui travaillerait sur le script.
Comme dit prĆ©cĆ©demment, un package contient un certain nombre de fonctions qui permettent de faire toutes sortes de manipulations sur des bases de donnĆ©es ou autres. Le repository officiel où sont stockĆ©s tous les packages R est appelĆ© CRAN ; āthe Comprehensive R Archive Networkā. Pour installer un package depuis le CRAN il faut utiliser la fonction install.packages("nom_package"). Mais il existe dāautres dĆ©pĆ“ts des packages crƩƩs, tel que Git (GitHub, GitLab, Bitbucketā¦) ; pour installer un package stockĆ© sur github par exemple il faut utiliser la fonction install_github("user_name/package_name"), elle-mĆŖme contenue dans le package devtools.
Pour utiliser un package, aprĆØs lāavoir installĆ©, il faut lāappeler via la fonction library(nom_package). Le code ci-dessous permet dāinstaller les packages fondamentaux, il faut le copier, le coller dans un script R basique (File > New File > R Script) puis lāexĆ©cuter.
Plusieurs packages sont attachĆ©s au ātidyverseā :
packages <- c("tidyverse", "remotes", "devtools", "rmarkdown", "rio", "datasets")
install.packages(packages)
Il est possible dāimporter des donnĆ©es dans lāenvironnement RStudio de deux maniĆØres : par un fichier exportĆ© prĆ©sent sur notre machine, ou directement via un lien qui pointe vers le tĆ©lĆ©chargement de ce fichier en ligne. Voici quelques exemples de plates-formes où il est possible dāen importer les donnĆ©es sans besoin prĆ©alable dāexporter le fichier :
Bonne pratique
Un autre bon rĆ©flexe est de privilĆ©gier tant que possible lāimport via un lien, puisque Ƨa nāimplique aucune manipulation extĆ©rieure au script, donc une plus grande reproductibilitĆ© pour partager ou automatiser le code.
Il existe un certain nombre de formats de jeux de donnƩes, nous allons lister les plus courants en prƩcisant la commande qui permet de les lire sous R et importer les donnƩes correctement.
library(readxl)
data <- read_excel(path = "chemin_acces/vers_le/fichier.xlsx", sheet = "feuille_n_1") # préciser le nom de la feuille à importer s'il y en a plusieurs
library(readr)
data <- read_csv("fichier.csv")
library(readr)
data <- read_delim("fichier.csv", delim = ";")
library(readr)
data <- read_delim("fichier.txt") # le dƩlimiteur est reconnu automatiquement par R, c'est "\t"
# ou
data <- read_table("fichier.txt")
Il existe encore bien dāautres formats de fichiers tels que XML, JSON, SAS⦠Si besoin, vous trouverez toute lāaide nĆ©cessaire sur internet (notamment sur Stack Overflow vu en partie prĆ©cĆ©dente).
Astuce
Lorsque vous avez un doute sur lāutilisation dāune fonction et que vous voulez savoir quels arguments elle attend et comment les spĆ©cifier, vous pouvez placer le curseur de la souris sur le nom de la fonction Ć©crite dans le script puis appuyer sur les touches Ctrl-F1 ; la page dāaide de la fonction sāouvrira dans la partie infĆ©rieure droite (Help) de la fenĆŖtre RStudio.
Si vous avez un doute pour importer vos donnƩes, vous pouvez le faire en presse-bouton via le menu : File > Import Dataset > From
Il est possible de ājouerā avec les paramĆØtres si ceux par dĆ©faut ne sont pas bons ; par exemple changer le sĆ©parateur de valeurs (Delimiter), lāencoding pour reconnaĆ®tre les caractĆØres spĆ©ciaux (Locale : Configureā¦), le nom de la base de donnĆ©es (Name), le nombre de lignes Ć ignorer en cas dāen-tĆŖte sur le fichier (Skip). Avant de finaliser lāimport des donnĆ©es par le menu, il est important de copier le code qui apparaĆ®t en bas Ć droite de la fenĆŖtre (Code Preview) puis le coller dans le script, pour ne pas refaire cette manipulation Ć chaque ouverture du script, et pour le rendre reproductible.
Entre une liste de notes dāĆ©lĆØves et une liste de noms de villes, on voit bien que la structure de donnĆ©es est diffĆ©rente. Listons ici les diffĆ©rents types de donnĆ©es qui existent, avant de voir comment les nettoyer :
| Famille de donnƩes | Structure | Nom retournƩ sous R | Exemple |
|---|---|---|---|
| quantitatif | entier | int = integer | 3 |
| dƩcimal inexact | dbl = double | 3.5 | |
| dƩcimal exact | num = numeric | 3.500001 | |
| qualitatif | chaîne de caractères | chr = character | Ville de Paris |
| facteur Ć n niveaux | Factor | petit / moyen / grand | |
| facteur Ć 2 niveaux dit āboolĆ©enā | bool = boolean | 0 / 1, True / False | |
| autre | date | POSIX | 13-12-1998 |
Bonne pratique
Bien que numériques, les identifiants tels que numéros de SIREN, numéros de marchés, etc. doivent être considérés comme une chaîne de caractères et non une valeur numérique.
Une fois importée, il est possible de regarder la structure des données qui composent la base grâce à la fonction str() :
# On importe des donnƩes ODS
data(iris)
# On regarde le type des variables qui composent la base
str(iris)
#> 'data.frame': 150 obs. of 5 variables:
#> $ Sepal.Length: num 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
#> $ Sepal.Width : num 3.5 3 3.2 3.1 3.6 3.9 3.4 3.4 2.9 3.1 ...
#> $ Petal.Length: num 1.4 1.4 1.3 1.5 1.4 1.7 1.4 1.5 1.4 1.5 ...
#> $ Petal.Width : num 0.2 0.2 0.2 0.2 0.2 0.4 0.3 0.2 0.2 0.1 ...
#> $ Species : Factor w/ 3 levels "setosa","versicolor",..: 1 1 1 1 1 1 1 1 1 1 ...
Nous rĆ©aliserons toutes sortes de manipulations sur une base de donnĆ©es dĆ©jĆ chargĆ©e dans lāenvironnement RStudio, cāest la base iris. Cette base recense des mesures de 4 attributs de 150 fleurs appartenant Ć 3 familles diffĆ©rentes. Plus dāinformations sur la base sur ce lien.
Il arrive que la structure dāune variable ne soit pas la bonne, il faut alors la changer pour avoir les donnĆ©es au bon format. Cela est possible grĆ¢ce Ć la fonction as.type_souhaite() :
# Pour passer en chaîne de caractères la variable "Species"
iris$Species <- as.character(iris$Species)
# Pour passer en nombres dƩcimaux arrondis les 4 autres variables (sans le faire une par une)
iris[,c(1:4)] <- lapply(iris[,c(1:4)], as.double)
Astuce
Pour accĆ©der Ć une variable dans une base de donnĆ©es, il et possible dāutiliser le ā$ā. Il fonctionne de la maniĆØre suivante ; base_de_donnees$variable.
La fonction lapply() permet dāappliquer une fonction Ć plusieurs variables simultanĆ©ment et permet ainsi de rĆ©duire le nombre de lignes de code dans le script.
VoilĆ quelques fonctions pour observer les donnĆ©es lorsquāelles viennent dāĆŖtre importĆ©es pour les cerner au mieux :
# 5 premiĆØres lignes
head(iris, 5)
#> Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#> 1 5.1 3.5 1.4 0.2 setosa
#> 2 4.9 3.0 1.4 0.2 setosa
#> 3 4.7 3.2 1.3 0.2 setosa
#> 4 4.6 3.1 1.5 0.2 setosa
#> 5 5.0 3.6 1.4 0.2 setosa
# 5 derniĆØres lignes
tail(iris, 5)
#> Sepal.Length Sepal.Width Petal.Length Petal.Width Species
#> 146 6.7 3.0 5.2 2.3 virginica
#> 147 6.3 2.5 5.0 1.9 virginica
#> 148 6.5 3.0 5.2 2.0 virginica
#> 149 6.2 3.4 5.4 2.3 virginica
#> 150 5.9 3.0 5.1 1.8 virginica
# Nombre de colonnes
ncol(iris)
#> [1] 5
# Nombre de lignes
nrow(iris)
#> [1] 150
length(iris)
#> [1] 5
# Nom des colonnes
names(iris)
#> [1] "Sepal.Length" "Sepal.Width" "Petal.Length" "Petal.Width" "Species"
# Nombre de lignes ET nombre de colonnes
dim(iris)
#> [1] 150 5
# RƩsumƩ des valeurs d'une variable
summary(iris$Petal.Length)
#> Min. 1st Qu. Median Mean 3rd Qu. Max.
#> 1.000 1.600 4.350 3.758 5.100 6.900
# Occurrences des valeurs d'une variable
table(iris$Species)
#>
#> setosa versicolor virginica
#> 50 50 50
Il arrive souvent que certaines valeurs manquent Ć une base de donnĆ©es, elles peuvent alors prendre plusieurs Ć©critures : NA, NaN, N/A, NC, NULL⦠La plus connue Ć©tant āNAā qui signifie Not Available. La fonction is.na() peut ĆŖtre appliquĆ©e pour connaĆ®tre le nombre de valeurs manquantes dans une base de donnĆ©es, et na.omit() pour supprimer toutes les lignes qui contiennent au moins 1 valeur manquante.
# Compter le nombre de NA dans une colonne
data %>% count(is.na(nom_colonne))
# Retirer toutes les lignes avec au moins 1 NA
new_data <- na.omit(data)
On parle de ātidy dataā Ć partir du moment où les donnĆ©es sont propres, cāest-Ć -dire quāelles respectent le schĆ©ma ci-dessous :
Chaque ligne est une observation et chaque colonne est une variable correspondant Ć lāobservation en question. Selon le format des donnĆ©es les observations peuvent correspondre Ć des individus/pays/villes etc. (on parle de donnĆ©es en coupe, cāest-Ć -dire une āphotoā dāune situation Ć un moment prĆ©cis), Ć des pĆ©riodes de temps (on parle de donnĆ©es temporelles) ou aux 2 simultanĆ©ment cāest-Ć -dire par individu et dans le temps (on parle alors de donnĆ©es de panel).
Dans un premier temps nous allons voir les diffĆ©rentes fonctions qui composent le dplyr et permettent de transformer les donnĆ©es, il sāagit des fonctions suivantes :
filter() : pour sĆ©lectionner certaines lignes Ć partir dāune conditionarrange() : pour rĆ©ordonner les lignesrename() : pour changer le nom des colonnes (renommer)select() : pour sĆ©lectionner certaines colonnesmutate() : pour crĆ©er de nouvelles variablessummarise() : pour rĆ©sumer plusieurs valeurs en 1 valeur (moyenne, mĆ©diane, modeā¦)group_by() : pour grouper les observations avant dāappliquer une fonctionfilter()Cette fonction sert Ć sĆ©lectionner des lignes dans une base de donnĆ©es (dataframe ; df). Les lignes qui rĆ©pondent Ć un certain critĆØre ou condition logique sont sĆ©lectionnĆ©es. Les filtres peuvent ĆŖtre appliquĆ©s tant aux variables quantitatives que qualitatives. Par exemple :
# On appelle la librairie tidyverse qui contient toutes ces fonctions et le pipe
library(tidyverse)
# Fleurs de l'espĆØce "versicolor"
df1 <- iris %>% filter(Species == "versicolor")
dim(df1)
#> [1] 50 5
# Fleurs dont les pétales sont supérieurs ou égaux à 5 cm
df2 <- iris %>% filter(Petal.Length >= 5)
dim(df2)
#> [1] 46 5
# Fleurs de l'espèce versicolor ET dont les pétales sont supérieurs ou égaux à 5 cm
df3 <- iris %>% filter(Species == "versicolor" & Petal.Length >= 5)
dim(df3)
#> [1] 2 5
# Fleurs dont les pƩtales sont exactement larges de 2 OU de 2.5 cm
df4 <- iris %>% filter(Petal.Width == 2 | Petal.Width == 2.5)
dim(df4)
#> [1] 9 5
Avec le pipe () on part de la base de données entière puis on applique nos filtres. On obtient ici deux sous-dataframes, et grâce à la fonction
dim() on voit que lāon a :
Le tableau ci-dessous rĆ©sume les filtres que lāon peut appliquer sur une plusieurs variable(s) dāune base de donnĆ©es. Pour filtrer des variables qualitatives il faut mettre la condition entre guillemets pour que la machine reconnaisse quāil sāagit dāun texte.
| Equation | Traduction pour R | Exemple |
|---|---|---|
| Ć©gal | == | Species == āversicolorā |
| diffĆ©rent | != | Species != āsetosaā |
| supƩrieur | > | Petal.Length > 5 |
| supƩrieur ou Ʃgal | >= | Petal.Length >= 5 |
| infƩrieur | < | Petal.Length < 5 |
| infƩrieur ou Ʃgal | <= | Petal.Length <= 5 |
arrange()Cette fonction sert à réordonner les observations selon un ordre alphabétique ou numérique croissant ou décroissant. Quelques exemples ci-dessous :
# On trie par longueur de sƩpale ascendante
iris <- iris %>% arrange(Sepal.Length)
# On trie par longueur de pƩtale descendante
iris <- iris %>% arrange(desc(Petal.Length))
# On trie par espèce puis par largeur de pétale ascendante
iris <- iris %>% arrange(Species, Petal.Width)
Bonne pratique
Ici nous avons attribuĆ© les changements sur la mĆŖme base de donnĆ©es āirisā, ce qui a āĆ©crasĆ©ā lāancienne par la nouvelle dans laquelle les observations sont triĆ©es dāune certaine maniĆØre. Lorsque vous ĆŖtes sĆ»rs de vos modifications vous pouvez attribuer les modifications au mĆŖme nom dāobjet ce qui Ć©crasera lāancien, mais dĆØs lors que vous voulez garder une trace de la base initiale il convient de crĆ©er un nouvel objet, cāest-Ć -dire avec un nouveau nom qui apparaĆ®tra dans votre environnement de travail (partie supĆ©rieure droite de la fenĆŖtre RStudio).
rename()Cette fonction permet de renommer une ou plusieurs colonnes dāun dataframe, elle fonctionne de la maniĆØre suivante : data <- data %>% rename(nouveau_nom = ancien_nom). Ci-dessous un exemple :
# On renomme 2 colonnnes
iris <- iris %>% rename(espece = Species,
longueur_petale = Petal.Length)
# Noms de colonnes en majuscules
names(iris) <- names(iris) %>% toupper
# Noms de colonnes en minuscules
names(iris) <- names(iris) %>% tolower
select()Cette fonction permet de sƩlectionner certaines colonnes, cela est possible en les identifiant par leur nom ou leur place dans le dataframe (numƩro de colonne). Quelques exemples :
# Sous df (dataframe) avec 2 colonnes
df5 <- iris %>% select(espece, sepal.width)
# ou
df5_bis <- iris %>% select(5, 2)
# Sous df sans 1 colonne
df6 <- iris %>% select(-longueur_petale)
# ou
df6_bis <- iris %>% select(-3)
# Sous df sans 2 colonnes
df6 <- iris %>% select(-c(longueur_petale,petal.width)) # c() permet de mettre dans 1 objet plusieurs arguments sƩparƩs par des virgules
# ou
df6_bis <- iris %>% select(-c(3,4))
# On change l'ordre des colonnes
iris <- iris %>% select(5,2:4,1)
Astuce
Lorsquāun nom de colonne contient un espace (par exemple : taille individu) il faut lāentourer de ` pour quāil soit reconnu comme le nom dāune seule colonne par R. Sans cette astuce, la commande ne pourra pas sāexĆ©cuter, dāoù lāimportance de nommer les bases de donnĆ©es et leurs variables par des noms sĆ©parĆ©s par les caractĆØres - ou _.
Exemple de mauvaise commande : data$premier nom <- as.numeric(data$premier nom)
Exemple de bonne commande : data$`premier nom` <- as.numeric(data$`premier nom`)
mutate()Cette fonction permet de crĆ©er de nouvelles variables Ć partir des variables existantes, elle est trĆØs utile pour lāanalyse de donnĆ©es. Elle fonctionne de la maniĆØre suivante :
data <- data %>% mutate(nouvelle_colonne = ancienne_colonne*100)
La āmutationā peut ĆŖtre arithmĆ©tique comme textuelle.
# On crƩƩ 1 colonne et on modifie 1 autre
iris <- iris %>% mutate(pourcentage_max_petale_width = petal.width / max(petal.width) *100,
espece = paste("L'espĆØce est", espece, sep = ": "))
# On affiche les 5 premières lignes des variables crées
head(iris[,c(1,6)], 5)
#> espece pourcentage_max_petale_width
#> 1 L'espĆØce est: setosa 4
#> 2 L'espĆØce est: setosa 4
#> 3 L'espĆØce est: setosa 4
#> 4 L'espĆØce est: setosa 4
#> 5 L'espĆØce est: setosa 4
La commande ci-dessus a par exemple permis de créer une variable qui informe à combien de points de pourcentage la largeur du pétale se situe par rapport à la largeur maximale.
En deuxiĆØme argument de la fonction mutate() on modifie la variable espece (on Ć©crase lāancienne variable) en ajoutant du texte grĆ¢ce Ć la fonction paste(). Cette derniĆØre permet de coller du texte, ici avant chaque espĆØce de fleur on ajoute āLāespĆØce est:ā, puis on colle le nom actuel de lāespĆØce qui se trouve dans la base (sep correspondant au sĆ©parateur entre le texte ajoutĆ© et lāancienne valeur).
summarise()Cette fonction permet de résumer plusieurs valeurs en une seule, ce qui est très utile pour avoir quelques statistiques sur les bases de données.
# Calcul de la longueur moyenne des pƩtales
iris %>% summarise(moyenne_PL = mean(longueur_petale))
#> moyenne_PL
#> 1 3.758
# Calcul de la largeur maximale des sƩpales
iris %>% summarise(max(sepal.width))
#> max(sepal.width)
#> 1 4.4
# Calcul des minimums des mesures des pƩtales
iris %>% summarise(min(petal.width),
min(longueur_petale))
#> min(petal.width) min(longueur_petale)
#> 1 0.1 1
On peut aussi calculer des statistiques sur toutes les variables Ć la fois avec la fonction summarise_all() :
# Calcul des mƩdianes de toutes les variables
iris %>% summarise_all(median)
#> espece sepal.width longueur_petale petal.width sepal.length
#> 1 NA 3 4.35 1.3 5.8
#> pourcentage_max_petale_width
#> 1 52
# Calcul des Ʃcart-types et de la variance
iris %>% select(-espece) %>% summarise_all(list(sd, var)) #list() quand plusieurs mesures Ć la fois
#> sepal.width_fn1 longueur_petale_fn1 petal.width_fn1 sepal.length_fn1
#> 1 0.4358663 1.765298 0.7622377 0.8280661
#> pourcentage_max_petale_width_fn1 sepal.width_fn2 longueur_petale_fn2
#> 1 30.48951 0.1899794 3.116278
#> petal.width_fn2 sepal.length_fn2 pourcentage_max_petale_width_fn2
#> 1 0.5810063 0.6856935 929.61
On voit que la mĆ©diane nāa pas Ć©tĆ© calculĆ©e pour la variable āespeceā puisquāelle nāest pas numĆ©rique, la valeur retournĆ©e est donc NA (Not Available). Pour la deuxiĆØme commande qui calcule lāĆ©cart-type et la variance, on exclut donc cette variable qualitative grĆ¢ce Ć la fonction select() que nous avons vu prĆ©cĆ©demment.
| OpƩration | Commande R | Exemple |
|---|---|---|
| moyenne | mean | mean(Petal.Length) |
| mƩdiane | med | med(Petal.Length) |
| Ʃtendue | range | range(Petal.Length) |
| minimum | min | min(Petal.Length) |
| maximum | max | max(Petal.Length) |
| Ʃcart-type | sd | sd(Petal.Length) |
| variance | var | var(Petal.Length) |
| skewness | skewness | skewness(Petal.Length) |
| kurtosis | kurtosis | kurtosis(Petal.Length) |
| quantiles | quantile | quantile(Petal.Length, probs = seq(0, 1, 1/10) |
Le dernier argument des sĆ©quences de probabilitĆ©s pour les quantiles prĆ©cise le type de quantiles que lāon souhaite calculer :
quantile(Petal.Length, probs = seq(0, 1, 1/4) : pour obtenir les quartilesquantile(Petal.Length, probs = seq(0, 1, 1/10) : pour obtenir les dĆ©cilesquantile(Petal.Length, probs = seq(0, 1, 1/100) : pour obtenir les centiles etc.group_by()Cette derniĆØre fonction principale du tidyverse permet de grouper les variables, elle est spĆ©cialement utile en analyse de donnĆ©es pour calculer des statistiques par groupe (genre, pays, espĆØceā¦). group_by() prend le dataframe et le converti en une base groupĆ©e pour laquelle les opĆ©rations seront effectuĆ©es non plus sur la base entiĆØre mais pour chacun des groupes identifiĆ©s.
# Nombre d'observations par groupe
iris %>% group_by(espece) %>% summarise(n())
#> # A tibble: 3 x 2
#> espece `n()`
#> <chr> <int>
#> 1 L'espĆØce est: setosa 50
#> 2 L'espĆØce est: versicolor 50
#> 3 L'espĆØce est: virginica 50
# Calcul de la taille moyenne des pétales par espèce
iris %>% group_by(espece) %>% summarise(mean(longueur_petale))
#> # A tibble: 3 x 2
#> espece `mean(longueur_petale)`
#> <chr> <dbl>
#> 1 L'espĆØce est: setosa 1.46
#> 2 L'espĆØce est: versicolor 4.26
#> 3 L'espĆØce est: virginica 5.55
On voit par exemple que lāon a 50 fleurs par espĆØce dans notre base, et quāen moyenne lāespĆØce virginica a les plus longs pĆ©tales : 5.55cm.
Nous savons à présent comment traiter les données grâce aux principales fonctions du dplyr, mais une manipulation importante reste à apprendre ; les combinaisons de données. Il y a 4 types de fonctions dans le dplyr qui permettent la combinaison de données :
Toutes ces fonctions ont la même structure : les deux premiers arguments sont des dataframes, et le résultat sera une nouvelle base du même type que le df stipulé comme premier argument.
Pour illustrer les fonctions de jointures et les filtres nous les appliquerons aux 2 bases de donnƩes suivantes, reprises de la cheatsheet Data Wrangling :
Il y a 4 types de jointures applicables dĆØs lors quāune variable (colonne) est commune aux 2 df : cela peut ĆŖtre utile par exemple pour ajouter des informations dāune base extĆ©rieure (bases nationales telles que Sirene, PrĆ©noms, DECPā¦) Ć une base existante.
Il est nĆ©cessaire dāavoir une variable de jointure, dite āclĆ©ā (identifiants, numĆ©ros de SIRET, noms de paysā¦) qui permettra dāunir les 2 bases, elle se spĆ©cifie dans lāargument āby=ā. Ici, la clĆ© est x1 qui est prĆ©sente dans a comme dans b.
left_join(a, b, by = "x1") : ajoute les lignes communes de b à a. Cette fonction est la plus utilisée pour ajouter des informations extérieures à une base de données existante.
right_join(a, b, by = "x1") : ajoute les lignes communes de a Ć b
inner_join(a, b, by = "x1") : joint en ne gardant que les lignes communes aux 2 df
full_join(a, b, by = "x1") : joint les donnƩes en gardant toutes les valeurs
Astuce
Lorsque la variable de jointure (la clĆ©) nāa pas le mĆŖme nom dans les 2 bases Ć joindre, il est possible de spĆ©cifier les noms Ć matcher. La commande est alors la suivante, ācol_1ā correspondant au nom de colonne dans le df1, et āCol_n1ā dans le df2 :
new_df <- left_join(df1, df2, by = c("col_1" = "Col_n1"))
semi_join(a, b, by = "x1") : toutes les lignes dans a qui matchent celles dans b
anti_join(a, b, by = "x1") : toutes les lignes dans a qui ne matchent pas celles dans b
Pour illustrer les fonctions dāopĆ©rations et de liaisons nous les appliquerons aux 2 bases de donnĆ©es suivantes :
intersect(y, z) : lignes qui apparaissent dans y ET dans z
union(y, z) : lignes qui apparaissent dans y ET/OU dans z
setdiff(y, z) : lignes qui apparaissent dans y MAIS PAS dans z
bind_rows(y, z) : ajoute z Ć y en tant que nouvelles lignes
bind_cols(y, z) : ajoute z Ć y en tant que nouvelles colonnes
Bonne pratique
Les fonctions bind_rows() (ou rbind) et bind_cols() (ou cbind) font de simples liaisons entre 2 jeux de donnĆ©es, sans match prĆ©alable sur les valeurs communes. Elles ne peuvent donc ĆŖtre appliquĆ©es quāaux bases de donnĆ©es qui ont exactement les mĆŖmes spĆ©cifications :
bind_rows()bind_cols()La partie de visualisation qui vient aprĆØs lāimport, le nettoyage et le traitement est trĆØs importante dans la science et lāanalyse de donnĆ©es. Le mot-clĆ©, un plutĆ“t le package clĆ© pour faire des graphiques sous R est ggplot. Initialement dĆ©veloppĆ© par Hadley Wickham, ce package permet de crĆ©er facilement des graphiques de qualitĆ© avec une immense variĆ©tĆ© de paramĆØtres modifiables selon les besoins, ce qui permet de crĆ©er des graphiques adaptĆ©s Ć tous types de problĆØmes.
Quelque soit le graphique voulu, il y a toujours 3 ƩlƩments qui composent la fonction ggplot() :
data=aes(x,y)) pour indiquer les variables X (abscisses=axe horizontal) et Y (ordonnƩes=axe vertical), contrƓler la couleur, la taille ou la forme du dernier composantgeom_**()
Le tableau ci-dessous reprend tous les types de géométrie faisables à partir de la fonction ggplot :
| GƩomƩtrie | Commande R | Exemple |
|---|---|---|
| Nuage de points | geom_point |
|
| Ligne | geom_line |
|
| Boîte à moustaches | geom_boxplot |
|
| Violon | geom_violin |
|
| DensitƩ | geom_density |
|
| Histogramme | geom_histogram |
|
| Barres | geom_bar |
|
Nous allons maintenant construire un graphique pas-Ć -pas en introduisant tous les paramĆØtres modifiables Ć partir du package ggplot.
La structure de la fonction ggplot est la suivante, avec les 3 principaux ƩlƩments dƩcrits ci-dessus :
# ModĆØle d'une fonction ggplot
ggplot(data = <DATA>) +
<GEOM_FUNCTION>(mapping = aes(<MAPPINGS>))
Sur nos données de fleurs (iris) nous construisons un premier graphique en nuage de points où nous introduirons peu à peu différents paramètres.
# On recharge les donnƩes iris pour ne pas avoir les modifications des parties prƩcƩdentes
data(iris)
# Graphique en nuage de points
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length))
Sur ce graphique le plus basique :
ggplotgeom_** qui est ajoutée par un + (ici geom_point puisque nous voulons un nuage de points)x et y du mapping.Nous pouvons personnaliser les points en spécifiant certains paramètres tels que :
color ou colour : la couleur des pointssize : la taille des points (par dĆ©faut Ć 1)alpha : lāopacitĆ© des points (0 < alpha < 1, où 1 correspond Ć une opacitĆ© totale)shape : la forme des pointsAstuce
Pour tous ces paramĆØtres, un argument normal peut ĆŖtre spĆ©cifie (āredā pour la couleur, 2 pour la taille etc.), mais il est aussi possible de mettre le nom dāune autre variable de maniĆØre Ć intĆ©grer une information supplĆ©mentaire au graphique. Ce peut ĆŖtre une variable catĆ©gorielle pour la couleur, une variable numĆ©rique pour la taille des points etc.
# Graphique en nuage de points personnalisƩ
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length),
color = "blue", size = 2, alpha = 0.7, shape = 2)
Il existe sur R deux maniĆØres de renseigner les couleurs : soit en spĆ©cifiant la couleur par son nom (exemple : ābrownā), soit en la spĆ©cifiant par son code Hex (exemple : ā#dd9933ā). Il sāagit dāune chaĆ®ne de 6 caractĆØres (chiffres et/ou lettres) qui correspond Ć une couleur que lāon peut crĆ©er soi-mĆŖme, sur le tableau ci-dessous on retrouve une palette de couleurs dĆ©jĆ crƩƩes pour lesquelles on a le code HEX.
Les formes des points peuvent aussi ĆŖtre spĆ©cifiĆ©es de deux maniĆØres : soit par un chiffre (exemple : 18) qui correspond Ć une forme dĆ©jĆ dĆ©finie visible dans le tableau ci-dessous, soit par un caractĆØre - un seul (exemple : āBā), qui sera utilisĆ© comme forme de point.
| Les couleurs | Les formes |
|---|---|
|
|
|
| pour plus dāinformations | pour plus dāinformations |
# Forme et couleur selon l'espĆØce de fleur
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species))
# Taille et opacitƩ selon la largeur du pƩtale
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, alpha = Petal.Width, size = Petal.Width))
Sur les graphiques ci-dessus on a dĆ©fini les paramĆØtres visuels des points selon dāautres variables du dataframe āirisā. Comme il sāagit de variables, leur spĆ©cification se fait Ć lāintĆ©rieur de la parenthĆØse aes() qui pour rappel, correspond aux propriĆ©tĆ©s esthĆ©tiques.
Par dĆ©faut le nom des variables sera mis comme label aux axes des abscisse et des ordonnĆ©es, mais il est possible de les modifier ou dāajouter des titres au graphique grĆ¢ce Ć la fonction labs(), qui peut ĆŖtre ajoutĆ©e aux paramĆØtres actuels par un +.
# Titres du graphique
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
labs(title = "Relation entre les longueurs des sƩpales et des pƩtales",
subtitle = "Différenciée par espèce de fleur",
caption = "DonnƩes de la base Iris",
x = "Longueur du sƩpale",
y = "Longueur du pƩtale")
Pour nāavoir aucun titre sur le graphique il suffit de spĆ©cifier x et y = NULL dans la fonction labs() :
# Aucun titre
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
labs(x = NULL,
y = NULL)
Il est possible de modifier lāapparence du graphique (taille, polices et couleur des titres, fond du graphique, quadrillages etc.) de deux maniĆØres :
theme() qui peut sāajouter Ć la suite des paramĆØtres existant du graphique par un +theme_**()La liste complĆØte des thĆØmes disponibles se trouve au lien ggplot2.tidyverse.org, voilĆ quelques exemples de thĆØmes appliquĆ©s Ć notre graphique en construction :
# ThĆØmes
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme_minimal()
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme_classic()
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme_light()
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme_dark()
Dāautres encore sont disponibles dans le package ggthemes, lāutilisation est la mĆŖme que pour les thĆØmes de ggplot2, aprĆØs avoir installĆ© le package (install.package(āggthemesā)). La liste des thĆØmes disponibles dans ce package se trouve ici.
Les éléments de légende peuvent être modifiés comme arguments de la fonction theme() que nous venons de voir, il est possible de modifier la position, le titre, les textes, les couleurs de la légende. Quelques exemples :
# Position
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme(legend.position = "top") #top, bottom, left or right
# ParamƩtrage du titre de la lƩgende
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme(legend.title = element_text(color="blue", size=10,
face="bold"))
# ParamƩtrage du texte de la lƩgende
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme(legend.text = element_text(colour="red", size=10,
face="italic"))
# Supprimer la lƩgende
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
theme(legend.position = "none")
Astuce
Bien que lāapparence puisse ĆŖtre dĆ©finie par la fonction theme_**(), il est possible de modifier les paramĆØtres du thĆØme existant en ajoutant aprĆØs celle-ci la fonction theme() - dans laquelle il est par exemple possible de modifier les Ć©lĆ©ments de la lĆ©gende, comme ci-dessus.
Lorsque lāon veut reprĆ©senter graphiquement les donnĆ©es par groupe on peut le faire de diffĆ©rentes maniĆØres :
Dans le package ggplot ce sont les fonctions facet_grid() et facet_wrap() qui permettent de crĆ©er des āfacettesā Ć un graphique, selon une variable catĆ©gorielle (un groupe).
# Facettes sur une seule ligne avec facet_grid
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
facet_grid(cols = vars(Species))
# Facettes sur une seule colonne avec facet_grid
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
facet_grid(rows = vars(Species))
# Facettes en matrice avec facet_wrap
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
facet_wrap(vars(Species), ncol = 2, nrow = 2)
La fonction lims() permet de spécifier soi-même les limites du graphique, de la manière suivante : c(min, max).
# Modification des limites
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
lims(x = c(1,10), y = c(2,7))
Avec le package ggplot il est facile de combiner plusieurs géométries sur un même graphique. Sur les visualisations qui suivent, nous avons ajouté une ligne qui relie tous les points grâce à la fonction geom_line(), puis une ligne qui représente la tendance générale (courbe lissée) grâce à la fonction geom_smooth().
# Geom_point + geom_line
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
geom_line(mapping = aes(x = Sepal.Length, y = Petal.Length))
# Geom_point + geom_smooth
ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species)) +
geom_smooth(mapping = aes(x = Sepal.Length, y = Petal.Length)) #ou stat_smooth()
Le boxplot aussi appelĆ© la boĆ®te Ć moustaches permet de visualiser une distribution, de la mĆŖme maniĆØre quāun histogramme, violin plot ou graphique en densitĆ© le permettent. Sur le graphique de droite nous ajoutons la moyenne de chaque longueur de sĆ©pale par espĆØce, grĆ¢ce Ć la fonction stat_summary(). Celle-ci permet dāintĆ©grer aux graphiques des statistiques, sans besoin de les calculer avant le graphique. Lāargument fun permet de prĆ©ciser le type de statistique souhaitĆ© ; ici fun = mean pour reprĆ©senter par un point la moyenne de la variable āSepal.Lengthā.
# Box plot
ggplot(data = iris) +
geom_boxplot(mapping = aes(x = Species, y = Sepal.Length))
# Box plot avec valeur moyenne pour chaque espĆØce
ggplot(data = iris) +
geom_boxplot(mapping = aes(x = Species, y = Sepal.Length)) +
stat_summary(mapping = aes(x = Species, y = Sepal.Length), fun = mean, color = 'red')
Les histogrammes permettent aussi dāobserver la distribution dāune variable, ils montrent le nombre dāobservations par valeur. Ici par exemple, 4 fleurs ont un sĆ©pale de moins de 4.5 cm et 1 fleur a un sĆ©pale de 4.5 cm. Sur le deuxiĆØme graphique on distingue par espĆØce, ce qui permet dāobserver des sĆ©pales plus longs pour lāespĆØce āvirginicaā et plus courts pour lāespĆØce āsetosaā.
# Histogramme
ggplot(data = iris) +
geom_histogram(mapping = aes(x = Sepal.Length))
# Histogramme colorƩ par groupe
ggplot(data = iris) +
geom_histogram(mapping = aes(Sepal.Length, fill = Species), #fill contrƓle la couleur de remplissage
color = 'black') #color contrƓle la couleur des bordures
Les graphiques en barres permettent de reprĆ©senter un montant, une rĆ©partition par variable catĆ©gorielle (groupes). Ici on regarde le nombre dāobservations (fleurs) de la base dans chaque espĆØce. Il y en a 50 par espĆØce don la reprĆ©sentation nāest pas trĆØs pertinente, mais on voit en deuxiĆØme graphique la mĆŖme visualisation avec les barres horizontales, ce qui est possible grĆ¢ce Ć la fonction coord_flip() que lāon ajoute Ć la suite du code existant.
# Bar plot
ggplot(data = iris) +
geom_bar(mapping = aes(x = Species))
# Bar plot horizontale
ggplot(data = iris) +
geom_bar(mapping = aes(x = Species)) +
coord_flip()
Il existe encore bien dāautres gĆ©omĆ©tries dans le package ggplot qui permettent de reprĆ©senter toutes sortes de variables. Les liens suivants aident Ć utiliser la bonne visualisation selon ce que lāon cherche Ć reprĆ©senter et/ou selon le type de variable :
https://clauswilke.com/dataviz/directory-of-visualizations.html
https://rkabacoff.github.io/datavis/
Lorsque lāon cherche Ć combiner plusieurs graphiques sur une mĆŖme page on peut utiliser la fonction grid.arrange() contenue dans le package gridExtra (install.packages("gridExtra") pour lāinstaller). Pour lāutiliser il faut au prĆ©alable sauvegarder les graphiques crƩƩs dans un objet, de maniĆØre Ć les appeler dans la fonction grid.arrange(). Dans un premier temps on combine 2 graphiques cĆ“te Ć cĆ“te sur une mĆŖme ligne donc sur 2 ācolonnesā (nrow = 1, et ncol = 2) :
# Box plot avec valeur moyenne pour chaque espĆØce
g1 <- ggplot(data = iris) +
geom_boxplot(mapping = aes(x = Species, y = Sepal.Length)) +
stat_summary(mapping = aes(x = Species, y = Sepal.Length), fun = mean, color = 'red')
# Histogramme colorƩ par groupe
g2 <- ggplot(data = iris) +
geom_histogram(mapping = aes(Sepal.Length, fill = Species),
color = 'black')
# Combinaison des graphiques
library(gridExtra)
grid.arrange(g1, g2, ncol = 2, nrow = 1)
Puis on les combine sur une mĆŖme colonne donc sur 2 lignes (nrow = 2, et ncol = 1) :
# Box plot avec valeur moyenne pour chaque espĆØce
g1 <- ggplot(data = iris) +
geom_boxplot(mapping = aes(x = Species, y = Sepal.Length)) +
stat_summary(mapping = aes(x = Species, y = Sepal.Length), fun = mean, color = 'red')
# Histogramme colorƩ par groupe
g2 <- ggplot(data = iris) +
geom_histogram(mapping = aes(Sepal.Length, fill = Species),
color = 'black')
# Combinaison des graphiques
grid.arrange(g1, g2, ncol = 1, nrow = 2)
Tous les graphiques que nous venons de voir jusquāici Ć©taient statiques, mais il est possible de les rendre dynamiques grĆ¢ce Ć la fonction ggplotly() contenue dans le package plotly (install.packages("plotly") pour lāinstaller). Il suffit de sauvegarder le graphique crƩƩ dans un objet puis de passer cet objet dans la fonction ggplotly() :
# Histogramme colorƩ par groupe
g1 <- ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species))
# Graphique dynamique
library(plotly)
ggplotly(g1)
Il est maintenant possible de zoomer sur le graphique, de capturer une image, de passer le curseur sur les diffĆ©rentes valeurs etc. On peut voir que lorsque lāon passe le curseur sur les points, les valeurs des variables entrĆ©es dans la fonction apparaissent ; on a ici āSepal.Lengthā, āSpeciesā et āPetal.Lengthā. Mais il est possible de customiser ce texte pour le rendre plus lisible, ce qui se fait directement dans le graphique ggplot puis est appelĆ© dans la fonction ggplotly().
# Histogramme colorƩ par groupe
g1 <- ggplot(data = iris) +
geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species, shape = Species,
text = paste("Fleur au pƩtale de", Petal.Length, "cm, et sƩpale de", Sepal.Length, "cm",
"\n", "EspĆØce", Species))) #"\n" permet d'aller Ć la ligne
# Graphique dynamique
ggplotly(g1, tooltip = c("text"))
Comme on le voit dans la commande, il faut utiliser la fonction paste() qui permet de coller du texte (entre guillemets) et la valeur des variables en sĆ©parant le tout par des virgules. Ce texte est Ć rentrer dans les paramĆØtres esthĆ©tiques (aes()), puis Ć appeler dans la fonction ggplotly() par lāargument tooltip = c("text").
Une fois les graphiques crƩƩs, il est possible de les exporter via la fonction ggsave() contenue dans le package ggplot. Le premier argument correspond au nom tel que sera exportĆ© le graphique, le second (plot) correspond Ć lāobjet crƩƩ sous R que lāon veut exporter, puis en 3ĆØ et 4ĆØ arguments peuvent ĆŖtre spĆ©cifiĆ©es les largeurs et hauteurs souhaitĆ©es pour le graphique. Il sāenregistrera dans le working directory actuel.
ggsave("mon_graphique.png", plot = g1, width = 8, height = 6)
Nous avons vu dans cette partie quelques bases pour construire un graphique sous R, mais beaucoup dāautres choses encore peuvent ĆŖtre ajoutĆ©es, modifiĆ©es etc. Vous pouvez trouver des modĆØles de graphique dĆ©jĆ construits sous R avec leur code sur R Graph Gallery, il ne reste plus quāĆ les modifier pour les appliquer Ć nos donnĆ©es.
Astuce
De la mĆŖme maniĆØre quāil est possible dāimporter des donnĆ©es en presse-boutons, il est aussi possible de construire des graphiques en presse-boutons rĆ©cupĆ©rer le code, et lāintĆ©grer au script existant. Cela est faisable avec la fonction esquisser() contenue dans le package esquisse (install.packages("esquisse") pour lāinstaller). Pour lāutiliser il suffit dāexĆ©cuter la commande suivante qui va ouvrir une fenĆŖtre permettant de construire un graphique pas-Ć -pas : esquisse::esquisser().
Enfin, la derniĆØre partie du schĆ©ma de traitement des donnĆ©es correspond Ć la communication des rĆ©sultats. Nous ne verrons que les rapports R Markdown (Rmd) dans cette partie, qui permettent de combiner du texte, du code, des graphiques, des images et des tableaux avec une mise en page propre et totalement personnalisable. Un document Rmd se crĆ©e via le menu : File > New File > R Markdown. Il est alors possible de prĆ©ciser un nom dāauteur et un titre au rapport, ainsi que le type de document qui sera gĆ©nĆ©rĆ©. 3 types existent : un document html (comme celui-ci), un document PDF ou encore un document Word. Selon lāusage le type de document choisi sera diffĆ©rent.
Astuce
Bien quāil faille choisir le type de document dĆØs la crĆ©ation du document Rmd, il est possible ensuite de changer le document alors quāil est en cours dāĆ©criture, ce qui permet de switcher facilement dāun format Ć un autre.
Tandis que les documents PDF et Word vont ĆŖtre sĆ©parĆ©s en pages et seront statiques, les documents html vont eux permettre dāintĆ©grer des tables ou des graphiques interactifs, des cartographies, des onglets et bien dāautres choses encore.
Après avoir créé un document R Markdown, vous pouvez générer le rapport en cliquant sur le bouton knit qui se trouve à droite du bouton de sauvegarde en dessous du titre du document.
Voici un exemple très simple de code R Markdown qui permet de générer un document au format html.
---
title: "Mon premier document Rmd"
author: "Moi"
date: "DƩcembre 2021"
output: html_document
---
Cette partie permet d'introduire le contenu du rapport dans sa globalitƩ.
```\{r}
head(iris, 5)
```
La partie juste au-dessus est un chunk de code R. Quand on compile le document (knit), le code sera exƩcutƩ et le rƩsultat se montrera en dessous dans le document html final.
Lāoutput de ce bout de code sera le suivant (sans le caractĆØre \ qui sert Ć Ć©chapper le chunk pour pas quāil ne run dans le corps du texte lui-mĆŖme) :
Dans tout document R Markdown on retrouve 3 types de contenus :
---, dans lequel on peut prĆ©ciser le tire, lāauteur, la date et le type de document cet en-tĆŖte est optionnel)```, dans lesquels on peut insĆ©rer du code qui sera exĆ©cutĆ© et apparaĆ®tra dans le document finalLes Ć©lĆ©ments basiques et gĆ©nĆ©raux peuvent ĆŖtre introduits dans lāen-tĆŖte du document, voici un exemple de header plus complet que lāon dĆ©composera par la suite pour voir comment fonctionne chaque partie :
---
title: "Titre du document"
author: "Auteur du document"
date: "`r Sys.Date()`"
output:
html_document:
theme: journal
highlight: textmate
toc: yes
toc_float: yes
toc_depth: 2
---
Le paramĆØtre date: "`r Sys.Date()`" donne la date du jour grĆ¢ce Ć la fonction Sys.Date() qui est mise Ć lāintĆ©rieur de lāargument `r `. Celui-ci permet dāexĆ©cuter du code R intĆ©grĆ© dans le corps du texte, sans besoin de crĆ©er un chunk R. Les paramĆØtres passĆ©s aprĆØs lāargument output: servent Ć spĆ©cifier le type de rapport qui sera gĆ©nĆ©rĆ©, il sāagit ici dāun document html (il faudrait spĆ©cifier output: pdf_document pour un document PDF, et output: word_document pour un Word).
Avec un autre niveau dāalinĆ©a on peut ensuite paramĆ©trer la mise en page avec les arguments theme et highlight, puis la table des matiĆØres avec toc, toc_float et toc_depth.
theme : il existe 12 thĆØmes qui ne nĆ©cessitent pas de packages supplĆ©mentaires et qui peuvent ĆŖtre utilisĆ©s facilement en spĆ©cifiant leur nom comme dans lāexemple ci-dessus (theme: journal). Dāun thĆØme Ć lāautre les polices, les tailles et les couleurs du texte peuvent changer : une liste des thĆØmes est disponible ici.
highlight : en complĆ©ment Ć lāargument theme qui spĆ©cifie la mise en page du texte (titres + corps du texte), lāargument highlight permet de paramĆ©trer la mise en page du code (des chunks) qui apparaĆ®t dans le rapport. Une liste des diffĆ©rents thĆØmes pour le code est disponible ici.
toc : cet argument permet dāintĆ©grer une table des matiĆØres (Table of contents : TOC) dans le rapport, elle sera gĆ©nĆ©rĆ©e automatiquement Ć partir du moment où la valeur āyesā lui est attribuĆ©e. La table des matiĆØres reprendra les titres et sous-titres du document.
toc_float : cette option permet de faire āflotterā la table des matiĆØres, de maniĆØre Ć ce quāelle reste toujours visible Ć gauche, mĆŖme lorsque le document dĆ©file.
toc_depth : cette option contrÓle la profondeur de la table des matières : ici par exemple seuls les titres de niveaux 1 et 2 apparaîtront dans la table.
Comme dit prĆ©cĆ©demment, les chunks sont des bouts de code R qui permettent de faire des analyses et dāafficher les rĆ©sultats dans le document final. Le code est reconnu comme du code et non du texte dĆØs lors quāil est placĆ© aprĆØs ```{r} et avant ```. On peut par exemple appeler des librairies, importer des donnĆ©es, les manipuler, les visualiser et les modĆ©liser. Globalement ; tout ce qui est faisable dans un script basique R (fichier.R) est faisable aussi dans un R Markdown, avec en plus la possibilitĆ© dāajouter des commentaires, des titres, des images etc.
Un chunk R peut être créé de la manière suivante :
Les chunks peuvent avoir plusieurs options qui permettent une plus grande flexibilitĆ© dans la maniĆØre dont le code et les rĆ©sultats seront affichĆ©s dans le document final. Les principales options sont les suivantes (issues du livre āR for Data Scienceā) :
eval = FALSE empĆŖche lāĆ©valuation du code, donc aucun rĆ©sultat ne sera gĆ©nĆ©rĆ©. Cette option peut ĆŖtre utile pour afficher un exemple de code sans lāexĆ©cuter.
include = FALSE exĆ©cute le code, mais nāaffiche ni le code ni les rĆ©sultats dans le document final. Cette option peut ĆŖtre utile pour le code de configuration quāon ne veut pas afficher dans le rapport final.
echo = FALSE empĆŖche le code, mais pas les rĆ©sultats dāapparaĆ®tre dans le fichier. Utile pour la rĆ©daction de rapports destinĆ©s Ć des personnes qui ne souhaitent pas voir le code R sous-jacent.
message = FALSE ou warning = FALSE empĆŖche lāapparition de messages ou dāavertissements dans le rapport final.
rƩsultats = 'hide' masque la sortie imprimƩe ; fig.show = 'hide' masque les tracƩs.
error = TRUE entraĆ®ne la poursuite du rendu mĆŖme si le code renvoie une erreur. La valeur par dĆ©faut, error = FALSE, entraĆ®ne lāĆ©chec du knit sāil y a une seule erreur dans le document.
Ces diffĆ©rentes options peuvent ĆŖtre mises Ć la suite du r dans les accolades du chunk, il est possible dāen mettre plusieurs qui doivent alors ĆŖtre sĆ©parĆ©es par des virgules (exemple : ```{r eval = TRUE, echo = FALSE}). Le tableau ci-dessous rĆ©capitule les options et leur effet sur le document final :
| Options | Run code | Montre code | RƩsultats | Graphiques | Messages | Warnings |
|---|---|---|---|---|---|---|
| eval = FALSE | ā | |||||
| include = FALSE | ā | |||||
| echo = FALSE | ā | ā | ā | ā | ā | |
| message = FALSE | ā | ā | ā | ā | ā | |
| warning = FALSE | ā | ā | ā | ā | ā | |
| results = āhideā | ā | ā | ā | ā | ā | |
| fig.show = āhideā | ā | ā | ā | ā | ā |
Astuce n°1
Il est possible de montrer ou de cacher tous les chunks par dĆ©faaut en spĆ©cifiant lāoption dans le YAML header. Dans lāexemple qui suit tous les codes seront montrĆ©s par dĆ©faut (āhideā pour cacher tous les codes par dĆ©faut) :
---
title: "Titre du document"
author: "Auteur du document"
date: "`r Sys.Date()`"
output:
html_document:
theme: journal
toc: yes
code_folding: show
---
Astuce n°2
Au lieu dāĆ©crire manuellement les options dans les chunks entre les accolades, il est possible dāutiliser le bouton qui se trouve en haut Ć droite du chunk.
|
|
Lorsque lāon veut dĆ©finir des options de chunk qui soient valables pour tous les chunks du document, il est possible de les dĆ©finir dāune maniĆØre gĆ©nĆ©rale (par dĆ©faut) au dĆ©but du script R Markdown. Cela est faisable grĆ¢ce Ć la fonction opts_chunk$set() du package knitr (install.packages("knitr") pour lāinstaller). Voici un exemple de chunk qui dĆ©finit les options par dĆ©faut, lui-mĆŖme aux options eval = FALSE et echo = TRUE pour montrer le code sans lāĆ©valuer. Ce chunk de paramĆØtres gĆ©nĆ©raux est Ć placer au dĆ©but du document, aprĆØs le YAML header.
library(knitr)
opts_chunk$set(echo = TRUE, # affiche le code
message = FALSE, # cache les messages d'erreurs
warning = FALSE, # cache les messages d'avertissements
fig.align = "center", # centre les figures
out.width = "80%") # affiche les figures Ć 80% de leur taille
Dans un document R Markdown, tout ce qui nāest pas en-tĆŖte ou code - que nous venons de voir, correspond au corps du texte. Le texte sāĆ©crit de la mĆŖme maniĆØre quāun fichier Word, mais la spĆ©cification de la mise en page va ĆŖtre diffĆ©rente : le texte en gras, les citations, les titres etc. Les captures dāĆ©crans ci-dessous montrent comment faire les principales mises en forme de texte en markdown.
| Texte brut | Rendu |
|---|---|
|
|
|
Pour finir voyons comment intégrer une image et une table à un document R Markdown.
Il y a plusieurs maniĆØres dāinsĆ©rer une image Ć un document Rmd, en voilĆ deux :
# Première façon
{width=120%}
# Deuxième façon
```\{r out.width='80%'}
knitr::include_graphics(here::here("lien/vers/l_image.png"))
```
La taille de lāimage est ajustable via les arguments width ou out.width. La premiĆØre commande pour intĆ©grer une image peut ĆŖtre placĆ©e telle quelle en corps de texte, dans un tableau ou encore au sein dāune phrase, tandis que la deuxiĆØme faƧon consiste Ć insĆ©rer un chunk R (sans le caractĆØre \ qui Ć©chappe le code) dans lequel on utilise la fonction include_graphics() qui permet dāafficher une image.
Il est possible dāintĆ©grer au texte dāun document Rmd un tableau en le crĆ©er directement sur le script. Il existe cependant des outils qui permettent de rĆ©aliser cette tĆ¢che plus facilement. Lāoutil Tables Generator permet de construire son tableau comme sur un Word, puis de rĆ©cupĆ©rer le code quāil ne reste plus quāĆ coller dans le script Rmd. Il est alors possible de choisir pour quel format le tableau doit ĆŖtre gĆ©nĆ©rĆ© ; dans notre cas il convient de choisir Markdown, ou HTML si lāoutput spĆ©cifiĆ© dans lāen-tĆŖte du document (YAML header) est un html.
Au long de cette formation on a pu apprendre Ć manipuler les donnĆ©es sous toutes ses formes en R. Sur lāinterface R Studio on a vu comment importer des donnĆ©es, les nettoyer, les transformer, les visualiser et communiquer sur lāanalyse avec les documents Markdown de R. Il existe dāautres documents pour communiquer les rĆ©sultats tels que slides, application Shiny, tableau de bord Flexdashboard etc. Si vous ĆŖtes curieux de connaĆ®tre de tels outils, vous trouverez toutes les ressources nĆ©cessaires sur internet. Il existe pour tous les livres crƩƩs sur ou pour R, un recensement complet que lāon trouve dans le livre : Big Book of R. Y sont rassemblĆ©s tous les tutoriels par thĆ©matique : Big Data, Data Science, Data Visualisation, Geospatial, Journalismā¦
Une rƩfƩrence incontournable pour approfondir la Data Science est le livre de Hadley Wickham & Garrett Grolemund ; R for Data Science (recensƩ en 10.2 dans Big Book of R).
En espérant que vous prendrez plaisir à programmer pour exploiter le potentiel des données, quittons-nous sur ce meme.